home *** CD-ROM | disk | FTP | other *** search
/ Aminet 24 / Aminet 24 (1998)(GTI - Schatztruhe)[!][Apr 1998].iso / Aminet / comm / mail / Mutt089src.lha / Mutt-0.89i-AMIGA / src / bind.c < prev    next >
C/C++ Source or Header  |  1998-01-28  |  5KB  |  189 lines
  1. /*
  2.  * Copyright (C) 1996-8 Michael R. Elkins <me@cs.hmc.edu>
  3.  *
  4.  *     This program is free software; you can redistribute it and/or modify
  5.  *     it under the terms of the GNU General Public License as published by
  6.  *     the Free Software Foundation; either version 2 of the License, or
  7.  *     (at your option) any later version.
  8.  *
  9.  *     This program is distributed in the hope that it will be useful,
  10.  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.  *     GNU General Public License for more details.
  13.  *
  14.  *     You should have received a copy of the GNU General Public License
  15.  *     along with this program; if not, write to the Free Software
  16.  *     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17.  */
  18.  
  19. #include "mutt.h"
  20. #include "mutt_curses.h"
  21. #include "keymap.h"
  22. #include "mapping.h"
  23.  
  24. #include <string.h>
  25.  
  26. static struct mapping_t Menus[] = {
  27.  { "alias",    MENU_ALIAS },
  28.  { "attach",    MENU_ATTACH },
  29.  { "browser",    MENU_FOLDER },
  30.  { "compose",    MENU_COMPOSE },
  31.  { "editor",    MENU_EDITOR },
  32.  { "generic",    MENU_GENERIC },
  33.  { "index",    MENU_MAIN },
  34.  { "pager",    MENU_PAGER },
  35. #ifdef _PGPPATH
  36.  { "pgp",    MENU_PGP },
  37. #endif /* _PGPPATH */
  38.  { NULL,    0 }
  39. };
  40.  
  41. #define mutt_check_menu(s) mutt_getvaluebyname(s, Menus)
  42.  
  43. /* expects to see: <menu-string> <key-string> */
  44. static const char *parse_keymap (int *menu,
  45.                  char *key,
  46.                  size_t keylen,
  47.                  const char *s,
  48.                  char *err,
  49.                  size_t errlen)
  50. {
  51.   char buf[SHORT_STRING];
  52.   char expn[SHORT_STRING];
  53.  
  54.   /* menu name */
  55.   s = mutt_extract_token (buf, sizeof (buf), s, expn, sizeof (expn), 0);
  56.  
  57.   if (s)
  58.   {
  59.     if ((*menu = mutt_check_menu (buf)) == -1)
  60.     {
  61.       snprintf (err, errlen, "%s: no such menu", s);
  62.       return (NULL);
  63.     }
  64.  
  65.     /* key sequence */
  66.     s = mutt_extract_token (key, keylen, s, expn, sizeof (expn), 0);
  67.  
  68.     if (s)
  69.       return s;
  70.   }
  71.  
  72.   strfcpy (err, "too few arguments", errlen);
  73.   return (NULL);
  74. }
  75.  
  76. static int
  77. try_bind (char *key, int menu, char *func, struct binding_t *bindings)
  78. {
  79.   int i;
  80.   
  81.   for (i = 0; bindings[i].name; i++)
  82.     if (strcmp (func, bindings[i].name) == 0)
  83.     {
  84.       km_bindkey (key, menu, bindings[i].op, NULL);
  85.       return (0);
  86.     }
  87.   return (-1);
  88. }
  89.  
  90. /* bind menu-name '<key_sequence>' function-name */
  91. int mutt_parse_bind (const char *s, void *data, char *err, size_t errlen)
  92. {
  93.   struct binding_t *bindings = NULL;
  94.   char buf[SHORT_STRING];
  95.   char key[SHORT_STRING];
  96.   char expn[SHORT_STRING];
  97.   int menu;
  98.  
  99.   if ((s = parse_keymap (&menu, key, sizeof (key), s, err, errlen)) == NULL)
  100.     return (-1);
  101.  
  102.   switch (menu)
  103.   {
  104.     case MENU_MAIN:
  105.       bindings = OpMain;
  106.       break;
  107.     case MENU_GENERIC:
  108.       bindings = OpGeneric;
  109.       break;
  110.     case MENU_COMPOSE:
  111.       bindings = OpCompose;
  112.       break;
  113.     case MENU_PAGER:
  114.       bindings = OpPager;
  115.       break;
  116.     case MENU_POST:
  117.       bindings = OpPost;
  118.       break;
  119.     case MENU_FOLDER:
  120.       bindings = OpBrowser;
  121.       break;
  122.     case MENU_ATTACH:
  123.       bindings = OpAttach;
  124.       break;
  125.     case MENU_EDITOR:
  126.       bindings = OpEditor;
  127.       break;
  128.     case MENU_ALIAS:
  129.       bindings = OpAlias;
  130.       break;
  131. #ifdef _PGPPATH
  132.     case MENU_PGP:
  133.       bindings = OpPgp;
  134.       break;
  135. #endif /* _PGPPATH */
  136.   }
  137.  
  138.   /* function to execute */
  139.   s = mutt_extract_token (buf, sizeof (buf), s, expn, sizeof (expn), 0);
  140.   if (s)
  141.   {
  142.     strfcpy (err, "too many arguments", errlen);
  143.     return (-1);
  144.   }
  145.  
  146.   if (strcasecmp ("noop", buf) == 0)
  147.   {
  148.     km_bindkey (key, menu, OP_NULL, NULL);
  149.     return 0;
  150.   }
  151.  
  152.   if (menu != MENU_PAGER && menu != MENU_EDITOR && menu != MENU_GENERIC)
  153.   {
  154.     /* First check the "generic" list of commands.  */
  155.     if (try_bind (key, menu, buf, OpGeneric) == 0)
  156.       return 0;
  157.   }
  158.  
  159.   /* Now check the menu-specific list of commands (if they exist).  */
  160.   if (bindings && try_bind (key, menu, buf, bindings) == 0)
  161.     return 0;
  162.  
  163.   snprintf (err, errlen, "%s: no such function in map", buf);
  164.   return (-1);
  165. }
  166.  
  167. /* macro <menu> <key> <macro> */
  168. int mutt_parse_macro (const char *s, void *data, char *err, size_t errlen)
  169. {
  170.   int menu;
  171.   char key[SHORT_STRING];
  172.   char buf[SHORT_STRING];
  173.   char expn[SHORT_STRING];
  174.  
  175.   if ((s = parse_keymap (&menu, key, sizeof (key), s, err, errlen)) == NULL)
  176.     return (-1);
  177.  
  178.   s = mutt_extract_token (buf, sizeof (buf), s, expn, sizeof (expn), M_CONDENSE);
  179.   if (s)
  180.   {
  181.     strfcpy (err, "too many arguments", errlen);
  182.     return (-1);
  183.   }
  184.  
  185.   km_bindkey (key, menu, OP_MACRO, buf);
  186.  
  187.   return 0;
  188. }
  189.